js = {}
js.Boot = function() { }
js.Boot.__name__ = ["js","Boot"];
js.Boot.__unhtml = function(s) {
	return s.split("&").join("&amp;").split("<").join("&lt;").split(">").join("&gt;");
}
js.Boot.__trace = function(v,i) {
	{
		var msg = (i != null?i.fileName + ":" + i.lineNumber + ": ":"");
		msg += js.Boot.__unhtml(js.Boot.__string_rec(v,"")) + "<br/>";
		var d = document.getElementById("haxe:trace");
		if(d == null) alert("No haxe:trace element defined\n" + msg);
		else d.innerHTML += msg;
	}
}
js.Boot.__clear_trace = function() {
	{
		var d = document.getElementById("haxe:trace");
		if(d != null) d.innerHTML = "";
		else null;
	}
}
js.Boot.__closure = function(o,f) {
	{
		var m = o[f];
		if(m == null) return null;
		var f1 = function() {
			return m.apply(o,arguments);
		}
		f1.scope = o;
		f1.method = m;
		return f1;
	}
}
js.Boot.__string_rec = function(o,s) {
	{
		if(o == null) return "null";
		if(s.length >= 5) return "<...>";
		var t = typeof(o);
		if(t == "function" && (o.__name__ != null || o.__ename__ != null)) t = "object";
		switch(t) {
		case "object":{
			if(o instanceof Array) {
				if(o.__enum__ != null) {
					if(o.length == 1) return o[0];
					var str = o[0] + "(";
					s += "\t";
					{
						var _g1 = 1, _g = o.length;
						while(_g1 < _g) {
							var i = _g1;
							++_g1;
							{
								if(i != 1) str += "," + js.Boot.__string_rec(o[i],s);
								else str += js.Boot.__string_rec(o[i],s);
							}
						}
					}
					return str + ")";
				}
				var l = o.length;
				var i;
				var str = "[";
				s += "\t";
				{
					var _g1 = 0, _g = l;
					while(_g1 < _g) {
						var i1 = _g1;
						++_g1;
						str += ((i1 > 0?",":"")) + js.Boot.__string_rec(o[i1],s);
					}
				}
				str += "]";
				return str;
			}
			var tostr;
			try {
				tostr = o.toString;
			}
			catch( $e0 ) {
				{
					var e = $e0;
					{
						return "???";
					}
				}
			}
			if(tostr != null && tostr != Object.toString) {
				var s2 = o.toString();
				if(s2 != "[object Object]") return s2;
			}
			var k;
			var str = "{\n";
			s += "\t";
			var hasp = (o.hasOwnProperty != null);
			for( var k in o ) { ;
			if(hasp && !o.hasOwnProperty(k)) continue;
			if(k == "prototype" || k == "__class__" || k == "__super__" || k == "__interfaces__") continue;
			if(str.length != 2) str += ", \n";
			str += s + k + " : " + js.Boot.__string_rec(o[k],s);
			}
			s = s.substring(1);
			str += "\n" + s + "}";
			return str;
		}break;
		case "function":{
			return "<function>";
		}break;
		case "string":{
			return o;
		}break;
		default:{
			return String(o);
		}break;
		}
	}
}
js.Boot.__interfLoop = function(cc,cl) {
	if(cc == null) return false;
	if(cc == cl) return true;
	var intf = cc.__interfaces__;
	if(intf != null) {
		var _g1 = 0, _g = intf.length;
		while(_g1 < _g) {
			var i = _g1;
			++_g1;
			{
				var i1 = intf[i];
				if(i1 == cl || js.Boot.__interfLoop(i1,cl)) return true;
			}
		}
	}
	return js.Boot.__interfLoop(cc.__super__,cl);
}
js.Boot.__instanceof = function(o,cl) {
	{
		try {
			if(o instanceof cl) {
				if(cl == Array) return (o.__enum__ == null);
				return true;
			}
			if(js.Boot.__interfLoop(o.__class__,cl)) return true;
		}
		catch( $e1 ) {
			{
				var e = $e1;
				{
					if(cl == null) return false;
				}
			}
		}
		switch(cl) {
		case Int:{
			return (Math.ceil(o) === o) && isFinite(o);
		}break;
		case Float:{
			return typeof(o) == "number";
		}break;
		case Bool:{
			return (o === true || o === false);
		}break;
		case String:{
			return typeof(o) == "string";
		}break;
		case Dynamic:{
			return true;
		}break;
		default:{
			if(o != null && o.__enum__ == cl) return true;
			return false;
		}break;
		}
	}
}
js.Boot.__init = function() {
	{
		js.Lib.isIE = (document.all != null && window.opera == null);
		js.Lib.isOpera = (window.opera != null);
		Array.prototype.copy = Array.prototype.slice;
		Array.prototype.insert = function(i,x) {
			this.splice(i,0,x);
		}
		Array.prototype.remove = function(obj) {
			var i = 0;
			var l = this.length;
			while(i < l) {
				if(this[i] == obj) {
					this.splice(i,1);
					return true;
				}
				i++;
			}
			return false;
		}
		Array.prototype.iterator = function() {
			return { next : function() {
				return this.arr[this.cur++];
			}, hasNext : function() {
				return this.cur < this.arr.length;
			}, arr : this, cur : 0}
		}
		String.prototype.__class__ = String;
		String.__name__ = ["String"];
		Array.prototype.__class__ = Array;
		Array.__name__ = ["Array"];
		var cca = String.prototype.charCodeAt;
		String.prototype.charCodeAt = function(i) {
			var x = cca.call(this,i);
			if(isNaN(x)) return null;
			return x;
		}
		var oldsub = String.prototype.substr;
		String.prototype.substr = function(pos,len) {
			if(pos != null && pos != 0 && len != null && len < 0) return "";
			if(len == null) len = this.length;
			if(pos < 0) {
				pos = this.length + pos;
				if(pos < 0) pos = 0;
			}
			else if(len < 0) {
				len = this.length + len - pos;
			}
			return oldsub.apply(this,[pos,len]);
		}
		Int = new Object();
		Dynamic = new Object();
		Float = Number;
		Bool = new Object();
		Bool["true"] = true;
		Bool["false"] = false;
		$closure = js.Boot.__closure;
	}
}
js.Boot.prototype.__class__ = js.Boot;
EReg = function(r,opt) { if( r === $_ ) return; {
	this.r = new RegExp(r,opt);
}}
EReg.__name__ = ["EReg"];
EReg.prototype.match = function(s) {
	{
		this.r.m = this.r.exec(s);
		this.r.s = s;
		this.r.l = RegExp.leftContext;
		this.r.r = RegExp.rightContext;
		return (this.r.m != null);
	}
}
EReg.prototype.matched = function(n) {
	return (this.r.m != null && n >= 0 && n < this.r.m.length?this.r.m[n]:function($this) {
		var $r;
		throw "EReg::matched";
		return $r;
	}(this));
}
EReg.prototype.matchedLeft = function() {
	{
		if(this.r.m == null) throw "EReg::matchedLeft";
		if(this.r.l == null) return this.r.s.substr(0,this.r.m.index);
		return this.r.l;
	}
}
EReg.prototype.matchedPos = function() {
	if(this.r.m == null) throw "EReg::matchedPos";
	return { len : this.r.m[0].length, pos : this.r.m.index}
}
EReg.prototype.matchedRight = function() {
	{
		if(this.r.m == null) throw "EReg::matchedRight";
		if(this.r.r == null) {
			var sz = this.r.m.index + this.r.m[0].length;
			return this.r.s.substr(sz,this.r.s.length - sz);
		}
		return this.r.r;
	}
}
EReg.prototype.r = null;
EReg.prototype.replace = function(s,by) {
	return s.replace(this.r,by);
}
EReg.prototype.split = function(s) {
	return s.split(this.r);
}
EReg.prototype.__class__ = EReg;
js.JsXml__ = function(p) { if( p === $_ ) return; {
	null;
}}
js.JsXml__.__name__ = ["js","JsXml__"];
js.JsXml__.parse = function(str) {
	var rules = [js.JsXml__.enode,js.JsXml__.epcdata,js.JsXml__.eend,js.JsXml__.ecdata,js.JsXml__.edoctype,js.JsXml__.ecomment,js.JsXml__.eprolog];
	var nrules = rules.length;
	var current = Xml.createDocument();
	var stack = new List();
	while(str.length > 0) {
		var i = 0;
		try {
			while(i < nrules) {
				var r = rules[i];
				if(r.match(str)) {
					switch(i) {
					case 0:{
						var x = Xml.createElement(r.matched(1));
						current.addChild(x);
						str = r.matchedRight();
						while(js.JsXml__.eattribute.match(str)) {
							x.set(js.JsXml__.eattribute.matched(1),js.JsXml__.eattribute.matched(3));
							str = js.JsXml__.eattribute.matchedRight();
						}
						if(!js.JsXml__.eclose.match(str)) {
							i = nrules;
							throw "__break__";
						}
						if(js.JsXml__.eclose.matched(1) == ">") {
							stack.push(current);
							current = x;
						}
						str = js.JsXml__.eclose.matchedRight();
					}break;
					case 1:{
						var x = Xml.createPCData(r.matched(0));
						current.addChild(x);
						str = r.matchedRight();
					}break;
					case 2:{
						if(current._children != null && current._children.length == 0) {
							var e = Xml.createPCData("");
							current.addChild(e);
						}
						else null;
						if(r.matched(1) != current._nodeName || stack.isEmpty()) {
							i = nrules;
							throw "__break__";
						}
						else null;
						current = stack.pop();
						str = r.matchedRight();
					}break;
					case 3:{
						str = r.matchedRight();
						if(!js.JsXml__.ecdata_end.match(str)) throw "End of CDATA section not found";
						var x = Xml.createCData(js.JsXml__.ecdata_end.matchedLeft());
						current.addChild(x);
						str = js.JsXml__.ecdata_end.matchedRight();
					}break;
					case 4:{
						var pos = 0;
						var count = 0;
						var old = str;
						try {
							while(true) {
								if(!js.JsXml__.edoctype_elt.match(str)) throw "End of DOCTYPE section not found";
								var p = js.JsXml__.edoctype_elt.matchedPos();
								pos += p.pos + p.len;
								str = js.JsXml__.edoctype_elt.matchedRight();
								switch(js.JsXml__.edoctype_elt.matched(0)) {
								case "[":{
									count++;
								}break;
								case "]":{
									count--;
									if(count < 0) throw "Invalid ] found in DOCTYPE declaration";
								}break;
								default:{
									if(count == 0) throw "__break__";
								}break;
								}
							}
						} catch( e ) { if( e != "__break__" ) throw e; }
						var x = Xml.createDocType(old.substr(0,pos));
						current.addChild(x);
					}break;
					case 5:{
						if(!js.JsXml__.ecomment_end.match(str)) throw "Unclosed Comment";
						var p = js.JsXml__.ecomment_end.matchedPos();
						var x = Xml.createComment(str.substr(0,p.pos + p.len));
						current.addChild(x);
						str = js.JsXml__.ecomment_end.matchedRight();
					}break;
					case 6:{
						var x = Xml.createProlog(r.matched(0));
						current.addChild(x);
						str = r.matchedRight();
					}break;
					}
					throw "__break__";
				}
				i += 1;
			}
		} catch( e ) { if( e != "__break__" ) throw e; }
		if(i == nrules) {
			if(str.length > 10) throw ("Xml parse error : Unexpected " + str.substr(0,10) + "...");
			else throw ("Xml parse error : Unexpected " + str);
		}
	}
	return current;
}
js.JsXml__.createElement = function(name) {
	var r = new js.JsXml__();
	r.nodeType = Xml.Element;
	r._children = new Array();
	r._attributes = new Hash();
	r.setNodeName(name);
	return r;
}
js.JsXml__.createPCData = function(data) {
	var r = new js.JsXml__();
	r.nodeType = Xml.PCData;
	r.setNodeValue(data);
	return r;
}
js.JsXml__.createCData = function(data) {
	var r = new js.JsXml__();
	r.nodeType = Xml.CData;
	r.setNodeValue(data);
	return r;
}
js.JsXml__.createComment = function(data) {
	var r = new js.JsXml__();
	r.nodeType = Xml.Comment;
	r.setNodeValue(data);
	return r;
}
js.JsXml__.createDocType = function(data) {
	var r = new js.JsXml__();
	r.nodeType = Xml.DocType;
	r.setNodeValue(data);
	return r;
}
js.JsXml__.createProlog = function(data) {
	var r = new js.JsXml__();
	r.nodeType = Xml.Prolog;
	r.setNodeValue(data);
	return r;
}
js.JsXml__.createDocument = function() {
	var r = new js.JsXml__();
	r.nodeType = Xml.Document;
	r._children = new Array();
	return r;
}
js.JsXml__.prototype._attributes = null;
js.JsXml__.prototype._children = null;
js.JsXml__.prototype._nodeName = null;
js.JsXml__.prototype._nodeValue = null;
js.JsXml__.prototype._parent = null;
js.JsXml__.prototype.addChild = function(x) {
	if(this._children == null) throw "bad nodetype";
	if(x._parent != null) x._parent._children.remove(x);
	x._parent = this;
	this._children.push(x);
}
js.JsXml__.prototype.attributes = function() {
	if(this.nodeType != Xml.Element) throw "bad nodeType";
	return this._attributes.keys();
}
js.JsXml__.prototype.elements = function() {
	if(this._children == null) throw "bad nodetype";
	return { next : function() {
		var k = this.cur;
		var l = this.x.length;
		while(k < l) {
			var n = this.x[k];
			k += 1;
			if(n.nodeType == Xml.Element) {
				this.cur = k;
				return n;
			}
		}
		return null;
	}, hasNext : function() {
		var k = this.cur;
		var l = this.x.length;
		while(k < l) {
			if(this.x[k].nodeType == Xml.Element) break;
			k += 1;
		}
		this.cur = k;
		return k < l;
	}, x : this._children, cur : 0}
}
js.JsXml__.prototype.elementsNamed = function(name) {
	if(this._children == null) throw "bad nodetype";
	return { next : function() {
		var k = this.cur;
		var l = this.x.length;
		while(k < l) {
			var n = this.x[k];
			k++;
			if(n.nodeType == Xml.Element && n._nodeName == name) {
				this.cur = k;
				return n;
			}
		}
		return null;
	}, hasNext : function() {
		var k = this.cur;
		var l = this.x.length;
		while(k < l) {
			var n = this.x[k];
			if(n.nodeType == Xml.Element && n._nodeName == name) break;
			k++;
		}
		this.cur = k;
		return k < l;
	}, x : this._children, cur : 0}
}
js.JsXml__.prototype.exists = function(att) {
	if(this.nodeType != Xml.Element) throw "bad nodeType";
	return this._attributes.exists(att);
}
js.JsXml__.prototype.firstChild = function() {
	if(this._children == null) throw "bad nodetype";
	return this._children[0];
}
js.JsXml__.prototype.firstElement = function() {
	if(this._children == null) throw "bad nodetype";
	var cur = 0;
	var l = this._children.length;
	while(cur < l) {
		var n = this._children[cur];
		if(n.nodeType == Xml.Element) return n;
		cur++;
	}
	return null;
}
js.JsXml__.prototype.get = function(att) {
	if(this.nodeType != Xml.Element) throw "bad nodeType";
	return this._attributes.get(att);
}
js.JsXml__.prototype.getNodeName = function() {
	if(this.nodeType != Xml.Element) throw "bad nodeType";
	return this._nodeName;
}
js.JsXml__.prototype.getNodeValue = function() {
	if(this.nodeType == Xml.Element || this.nodeType == Xml.Document) throw "bad nodeType";
	return this._nodeValue;
}
js.JsXml__.prototype.getParent = function() {
	return this._parent;
}
js.JsXml__.prototype.insertChild = function(x,pos) {
	if(this._children == null) throw "bad nodetype";
	if(x._parent != null) x._parent._children.remove(x);
	x._parent = this;
	this._children.insert(pos,x);
}
js.JsXml__.prototype.iterator = function() {
	if(this._children == null) throw "bad nodetype";
	return { next : function() {
		return this.x[this.cur++];
	}, hasNext : function() {
		return this.cur < this.x.length;
	}, x : this._children, cur : 0}
}
js.JsXml__.prototype.nodeName = null;
js.JsXml__.prototype.nodeType = null;
js.JsXml__.prototype.nodeValue = null;
js.JsXml__.prototype.parent = null;
js.JsXml__.prototype.remove = function(att) {
	if(this.nodeType != Xml.Element) throw "bad nodeType";
	this._attributes.remove(att);
}
js.JsXml__.prototype.removeChild = function(x) {
	if(this._children == null) throw "bad nodetype";
	var b = this._children.remove(x);
	if(b) x._parent = null;
	return b;
}
js.JsXml__.prototype.set = function(att,value) {
	if(this.nodeType != Xml.Element) throw "bad nodeType";
	this._attributes.set(att,value);
}
js.JsXml__.prototype.setNodeName = function(n) {
	if(this.nodeType != Xml.Element) throw "bad nodeType";
	return this._nodeName = n;
}
js.JsXml__.prototype.setNodeValue = function(v) {
	if(this.nodeType == Xml.Element || this.nodeType == Xml.Document) throw "bad nodeType";
	return this._nodeValue = v;
}
js.JsXml__.prototype.toString = function() {
	if(this.nodeType == Xml.PCData) return this._nodeValue;
	if(this.nodeType == Xml.CData) return "<![CDATA[" + this._nodeValue + "]]>";
	if(this.nodeType == Xml.Comment || this.nodeType == Xml.DocType || this.nodeType == Xml.Prolog) return this._nodeValue;
	var s = new StringBuf();
	if(this.nodeType == Xml.Element) {
		s.add("<");
		s.add(this._nodeName);
		{ var $it2 = this._attributes.keys();
		while( $it2.hasNext() ) { var k = $it2.next();
		{
			s.add(" ");
			s.add(k);
			s.add("=\"");
			s.add(this._attributes.get(k));
			s.add("\"");
		}
		}}
		if(this._children.length == 0) {
			s.add("/>");
			return s.toString();
		}
		s.add(">");
	}
	{ var $it3 = this.iterator();
	while( $it3.hasNext() ) { var x = $it3.next();
	s.add(x.toString());
	}}
	if(this.nodeType == Xml.Element) {
		s.add("</");
		s.add(this._nodeName);
		s.add(">");
	}
	return s.toString();
}
js.JsXml__.prototype.__class__ = js.JsXml__;
js.Lib = function() { }
js.Lib.__name__ = ["js","Lib"];
js.Lib.isIE = null;
js.Lib.isOpera = null;
js.Lib.alert = function(v) {
	alert(js.Boot.__string_rec(v,""));
}
js.Lib.eval = function(code) {
	return eval(code);
}
js.Lib.setErrorHandler = function(f) {
	js.Lib.onerror = f;
}
js.Lib.prototype.__class__ = js.Lib;
ValueType = { __ename__ : ["ValueType"] }
ValueType.TBool = ["TBool"];
ValueType.TBool.__enum__ = ValueType;
ValueType.TClass = function(c) { var $x = ["TClass",c]; $x.__enum__ = ValueType; return $x; }
ValueType.TEnum = function(e) { var $x = ["TEnum",e]; $x.__enum__ = ValueType; return $x; }
ValueType.TFloat = ["TFloat"];
ValueType.TFloat.__enum__ = ValueType;
ValueType.TFunction = ["TFunction"];
ValueType.TFunction.__enum__ = ValueType;
ValueType.TInt = ["TInt"];
ValueType.TInt.__enum__ = ValueType;
ValueType.TNull = ["TNull"];
ValueType.TNull.__enum__ = ValueType;
ValueType.TObject = ["TObject"];
ValueType.TObject.__enum__ = ValueType;
ValueType.TUnknown = ["TUnknown"];
ValueType.TUnknown.__enum__ = ValueType;
Type = function() { }
Type.__name__ = ["Type"];
Type.toEnum = function(t) {
	try {
		if(t.__ename__ == null) return null;
		return t;
	}
	catch( $e4 ) {
		{
			var e = $e4;
			null;
		}
	}
	return null;
}
Type.toClass = function(t) {
	try {
		if(t.__name__ == null) return null;
		return t;
	}
	catch( $e5 ) {
		{
			var e = $e5;
			null;
		}
	}
	return null;
}
Type.getClass = function(o) {
	if(o == null) return null;
	if(o.__enum__ != null) return null;
	return o.__class__;
}
Type.getEnum = function(o) {
	if(o == null) return null;
	return o.__enum__;
}
Type.getSuperClass = function(c) {
	return c.__super__;
}
Type.getClassName = function(c) {
	if(c == null) return null;
	var a = c.__name__;
	return a.join(".");
}
Type.getEnumName = function(e) {
	var a = e.__ename__;
	return a.join(".");
}
Type.resolveClass = function(name) {
	var cl;
	{
		try {
			cl = eval(name);
		}
		catch( $e6 ) {
			{
				var e = $e6;
				{
					cl = null;
				}
			}
		}
		if(cl == null || cl.__name__ == null) return null;
		else null;
	}
	return cl;
}
Type.resolveEnum = function(name) {
	var e;
	{
		try {
			e = eval(name);
		}
		catch( $e7 ) {
			{
				var e1 = $e7;
				{
					e1 = null;
				}
			}
		}
		if(e == null || e.__ename__ == null) return null;
		else null;
	}
	return e;
}
Type.createInstance = function(cl,args) {
	if(args.length >= 6) throw "Too many arguments";
	return new cl(args[0],args[1],args[2],args[3],args[4],args[5]);
}
Type.createEmptyInstance = function(cl) {
	return new cl($_);
}
Type.getInstanceFields = function(c) {
	var a = Reflect.fields(c.prototype);
	c = c.__super__;
	while(c != null) {
		a = a.concat(Reflect.fields(c.prototype));
		c = c.__super__;
	}
	while(a.remove("__class__")) null;
	return a;
}
Type.getClassFields = function(c) {
	var a = Reflect.fields(c);
	a.remove("__name__");
	a.remove("__interfaces__");
	a.remove("__super__");
	a.remove("prototype");
	return a;
}
Type.getEnumConstructs = function(e) {
	var a = Reflect.fields(e);
	a.remove("__ename__");
	return a;
}
Type["typeof"] = function(v) {
	switch(typeof(v)) {
	case "boolean":{
		return ValueType.TBool;
	}break;
	case "string":{
		return ValueType.TClass(String);
	}break;
	case "number":{
		if(v + 1 == v) return ValueType.TFloat;
		if(Math.ceil(v) == v) return ValueType.TInt;
		return ValueType.TFloat;
	}break;
	case "object":{
		if(v == null) return ValueType.TNull;
		var e = v.__enum__;
		if(e != null) return ValueType.TEnum(e);
		var c = v.__class__;
		if(c != null) return ValueType.TClass(c);
		return ValueType.TObject;
	}break;
	case "function":{
		if(v.__name__ != null) return ValueType.TObject;
		return ValueType.TFunction;
	}break;
	case "undefined":{
		return ValueType.TNull;
	}break;
	default:{
		return ValueType.TUnknown;
	}break;
	}
}
Type.enumEq = function(a,b) {
	if(a == b) return true;
	if(a[0] != b[0]) return false;
	{
		var _g1 = 1, _g = a.length;
		while(_g1 < _g) {
			var i = _g1;
			++_g1;
			if(!Type.enumEq(a[i],b[i])) return false;
		}
	}
	var e = a.__enum__;
	if(e != b.__enum__ || e == null) return false;
	return true;
}
Type.enumConstructor = function(e) {
	return e[0];
}
Type.enumParameters = function(e) {
	return e.slice(1);
}
Type.prototype.__class__ = Type;
haxe = {}
haxe.Log = function() { }
haxe.Log.__name__ = ["haxe","Log"];
haxe.Log.trace = function(v,infos) {
	js.Boot.__trace(v,infos);
}
haxe.Log.clear = function() {
	js.Boot.__clear_trace();
}
haxe.Log.prototype.__class__ = haxe.Log;
haxe.xml = {}
haxe.xml._Fast = {}
haxe.xml._Fast.NodeAccess = function(x) { if( x === $_ ) return; {
	this.__x = x;
}}
haxe.xml._Fast.NodeAccess.__name__ = ["haxe","xml","_Fast","NodeAccess"];
haxe.xml._Fast.NodeAccess.prototype.__resolve = function(name) {
	var x = this.__x.elementsNamed(name).next();
	if(x == null) {
		var xname = (this.__x.nodeType == Xml.Document?"Document":this.__x.getNodeName());
		throw xname + " is missing element " + name;
	}
	return new haxe.xml.Fast(x);
}
haxe.xml._Fast.NodeAccess.prototype.__x = null;
haxe.xml._Fast.NodeAccess.prototype.__class__ = haxe.xml._Fast.NodeAccess;
haxe.xml._Fast.AttribAccess = function(x) { if( x === $_ ) return; {
	this.__x = x;
}}
haxe.xml._Fast.AttribAccess.__name__ = ["haxe","xml","_Fast","AttribAccess"];
haxe.xml._Fast.AttribAccess.prototype.__resolve = function(name) {
	if(this.__x.nodeType == Xml.Document) throw "Cannot access document attribute " + name;
	var v = this.__x.get(name);
	if(v == null) throw this.__x.getNodeName() + " is missing attribute " + name;
	return v;
}
haxe.xml._Fast.AttribAccess.prototype.__x = null;
haxe.xml._Fast.AttribAccess.prototype.__class__ = haxe.xml._Fast.AttribAccess;
haxe.xml._Fast.HasAttribAccess = function(x) { if( x === $_ ) return; {
	this.__x = x;
}}
haxe.xml._Fast.HasAttribAccess.__name__ = ["haxe","xml","_Fast","HasAttribAccess"];
haxe.xml._Fast.HasAttribAccess.prototype.__resolve = function(name) {
	if(this.__x.nodeType == Xml.Document) throw "Cannot access document attribute " + name;
	return this.__x.exists(name);
}
haxe.xml._Fast.HasAttribAccess.prototype.__x = null;
haxe.xml._Fast.HasAttribAccess.prototype.__class__ = haxe.xml._Fast.HasAttribAccess;
haxe.xml._Fast.HasNodeAccess = function(x) { if( x === $_ ) return; {
	this.__x = x;
}}
haxe.xml._Fast.HasNodeAccess.__name__ = ["haxe","xml","_Fast","HasNodeAccess"];
haxe.xml._Fast.HasNodeAccess.prototype.__resolve = function(name) {
	return this.__x.elementsNamed(name).hasNext();
}
haxe.xml._Fast.HasNodeAccess.prototype.__x = null;
haxe.xml._Fast.HasNodeAccess.prototype.__class__ = haxe.xml._Fast.HasNodeAccess;
haxe.xml._Fast.NodeListAccess = function(x) { if( x === $_ ) return; {
	this.__x = x;
}}
haxe.xml._Fast.NodeListAccess.__name__ = ["haxe","xml","_Fast","NodeListAccess"];
haxe.xml._Fast.NodeListAccess.prototype.__resolve = function(name) {
	var l = new List();
	{ var $it8 = this.__x.elementsNamed(name);
	while( $it8.hasNext() ) { var x = $it8.next();
	l.add(new haxe.xml.Fast(x));
	}}
	return l;
}
haxe.xml._Fast.NodeListAccess.prototype.__x = null;
haxe.xml._Fast.NodeListAccess.prototype.__class__ = haxe.xml._Fast.NodeListAccess;
haxe.xml.Fast = function(x) { if( x === $_ ) return; {
	if(x.nodeType != Xml.Document && x.nodeType != Xml.Element) throw "Invalid nodeType " + x.nodeType;
	this.x = x;
	this.node = new haxe.xml._Fast.NodeAccess(x);
	this.nodes = new haxe.xml._Fast.NodeListAccess(x);
	this.att = new haxe.xml._Fast.AttribAccess(x);
	this.has = new haxe.xml._Fast.HasAttribAccess(x);
	this.hasNode = new haxe.xml._Fast.HasNodeAccess(x);
}}
haxe.xml.Fast.__name__ = ["haxe","xml","Fast"];
haxe.xml.Fast.prototype.att = null;
haxe.xml.Fast.prototype.elements = null;
haxe.xml.Fast.prototype.getElements = function() {
	var it = this.x.elements();
	return { next : function() {
		var x = it.next();
		if(x == null) return null;
		return new haxe.xml.Fast(x);
	}, hasNext : $closure(it,"hasNext")}
}
haxe.xml.Fast.prototype.getInnerData = function() {
	var it = this.x.iterator();
	if(!it.hasNext()) throw this.getName() + " does not have data";
	var v = it.next();
	if(it.hasNext()) throw this.getName() + " does not only have data";
	if(v.nodeType != Xml.PCData && v.nodeType != Xml.CData) throw this.getName() + " does not have data";
	return v.getNodeValue();
}
haxe.xml.Fast.prototype.getName = function() {
	return (this.x.nodeType == Xml.Document?"Document":this.x.getNodeName());
}
haxe.xml.Fast.prototype.has = null;
haxe.xml.Fast.prototype.hasNode = null;
haxe.xml.Fast.prototype.innerData = null;
haxe.xml.Fast.prototype.name = null;
haxe.xml.Fast.prototype.node = null;
haxe.xml.Fast.prototype.nodes = null;
haxe.xml.Fast.prototype.x = null;
haxe.xml.Fast.prototype.__class__ = haxe.xml.Fast;
hxbase = {}
hxbase.events = {}
hxbase.events._Event = {}
hxbase.events._Event.StopPropagate = { __ename__ : ["hxbase","events","_Event","StopPropagate"] }
hxbase.events._Event.StopPropagate.stop = ["stop"];
hxbase.events._Event.StopPropagate.stop.__enum__ = hxbase.events._Event.StopPropagate;
hxbase.events.EventHandlers = function() { }
hxbase.events.EventHandlers.__name__ = ["hxbase","events","EventHandlers"];
hxbase.events.EventHandlers.prototype.handlers = null;
hxbase.events.EventHandlers.prototype.__class__ = hxbase.events.EventHandlers;
hxbase.events.EventDispatchers = function() { }
hxbase.events.EventDispatchers.__name__ = ["hxbase","events","EventDispatchers"];
hxbase.events.EventDispatchers.prototype.events = null;
hxbase.events.EventDispatchers.prototype.__class__ = hxbase.events.EventDispatchers;
hxbase.events.Binding = function() { }
hxbase.events.Binding.__name__ = ["hxbase","events","Binding"];
hxbase.events.Binding.prototype.boundTo = null;
hxbase.events.Binding.prototype.disable = null;
hxbase.events.Binding.prototype.enable = null;
hxbase.events.Binding.prototype.unbind = null;
hxbase.events.Binding.prototype.__class__ = hxbase.events.Binding;
hxbase.events.Event = function(group) { if( group === $_ ) return; {
	this.parent = group;
	this.call = $closure(this,"dispatchCall");
	this.bubbleChain = { l : null, f : null}
}}
hxbase.events.Event.__name__ = ["hxbase","events","Event"];
hxbase.events.Event.current = null;
hxbase.events.Event.global = function(eventGroup) {
	var id = eventGroup._gid;
	var g;
	if(id > 0 && hxbase.events.EventGroup.global[id] != null) g = hxbase.events.EventGroup.global[id];
	else {
		g = Type.createEmptyInstance(eventGroup);
		if(!Std["is"](g,hxbase.events.EventGroup)) throw "Event.global() requires an EventGroup! Was called with: \"" + eventGroup + "\" instead.";
		g.init();
		id = eventGroup._gid;
		hxbase.events.EventGroup.global[id] = g;
	}
	if(g == null) throw "Null EventGroup. Are you sure you specified an EventGroup class as parameter?";
	return g;
}
hxbase.events.Event.bind = function(group,handlers) {
	null;
}
hxbase.events.Event.unbind = function(listener,handler,skipGlobalDispatchers) {
	if(listener instanceof hxbase.events.EventHandlers) {
		var h = listener.handlers;
		var b;
		{ var $it9 = Reflect.fields(h).iterator();
		while( $it9.hasNext() ) { var f = $it9.next();
		{
			b = Reflect.field(h,f);
			if(b.boundTo(listener,handler)) b.unbind();
		}
		}}
	}
	if(!skipGlobalDispatchers) {
		var l = hxbase.events.EventGroup.global;
		{
			var _g1 = 0, _g = l.length;
			while(_g1 < _g) {
				var id = _g1;
				++_g1;
				{
					l[id].unbind(listener,handler);
				}
			}
		}
	}
}
hxbase.events.Event.prototype.bind = function(listener,handler) {
	return new hxbase.events._Event.Bubble(this.bubbleChain,listener,handler);
}
hxbase.events.Event.prototype.bubbleChain = null;
hxbase.events.Event.prototype.call = null;
hxbase.events.Event.prototype.dispatchCall = function() {
	hxbase.events.Event.current = this;
	var b = this.bubbleChain.f;
	try {
		while(b != null) {
			if(b.h.apply(b.l,arguments) === true) break;
			b = b.n;
		}
	}
	catch( $e10 ) {
		if( js.Boot.__instanceof($e10,hxbase.events._Event.StopPropagate) ) {
			var e = $e10;
			null;
		} else throw($e10);
	}
	hxbase.events.Event.current = null;
}
hxbase.events.Event.prototype.parent = null;
hxbase.events.Event.prototype.stopPropagation = function() {
	if(hxbase.events.Event.current == this) throw hxbase.events._Event.StopPropagate.stop;
}
hxbase.events.Event.prototype.unbind = function(listener,handler) {
	var b = this.bubbleChain.l;
	if(handler == null) {
		var next;
		var found = false;
		while(b != null) {
			next = b.p;
			if(b.l == listener) {
				found = true;
				b.unbind();
			}
			b = next;
		}
		return found;
	}
	var found = false;
	while(b != null) {
		if(b.boundTo(listener,handler)) {
			b.unbind();
			found = true;
		}
		else b = b.p;
	}
	return found;
}
hxbase.events.Event.prototype.__class__ = hxbase.events.Event;
haxe.Public = function() { }
haxe.Public.__name__ = ["haxe","Public"];
haxe.Public.prototype.__class__ = haxe.Public;
haxe.rtti = {}
haxe.rtti.Infos = function() { }
haxe.rtti.Infos.__name__ = ["haxe","rtti","Infos"];
haxe.rtti.Infos.prototype.__class__ = haxe.rtti.Infos;
hxbase.events.EventGroup = function(p) { if( p === $_ ) return; {
	this.init();
}}
hxbase.events.EventGroup.__name__ = ["hxbase","events","EventGroup"];
hxbase.events.EventGroup.prototype.bind = function(cl) {
	null;
}
hxbase.events.EventGroup.prototype.getClass = function() {
	var cl = Type.getClass(this);
	{
		if(cl._gid == null) cl._gid = hxbase.events.EventGroup.global.length + 1;
		else null;
	}
	return cl;
}
hxbase.events.EventGroup.prototype.init = function() {
	var cl = this.getClass();
	var id = cl._gid;
	if(hxbase.events.EventGroup.rttiCache[id] == null) {
		hxbase.events.EventGroup.rttiCache[id] = new Array();
		var $e = (new haxe.rtti.XmlParser().processElement(Xml.parse(cl.__rtti).firstElement()));
		switch( $e[0] ) {
		case "TClassdecl":
		var c = $e[1];
		{
			{ var $it11 = c.fields.iterator();
			while( $it11.hasNext() ) { var f = $it11.next();
			var $e = (f.type);
			switch( $e[0] ) {
			case "TClass":
			var params = $e[2], name = $e[1];
			{
				if(name == "hxbase.events.Event") {
					hxbase.events.EventGroup.rttiCache[id].push(f.name);
					Reflect.setField(this,f.name,new hxbase.events.Event(this));
				}
			}break;
			default:{
				null;
			}break;
			}
			}}
		}break;
		default:{
			null;
		}break;
		}
	}
	else { var $it12 = hxbase.events.EventGroup.rttiCache[id].iterator();
	while( $it12.hasNext() ) { var f = $it12.next();
	Reflect.setField(this,f,new hxbase.events.Event(this));
	}}
}
hxbase.events.EventGroup.prototype.unbind = function(listener,handler) {
	var f;
	{ var $it13 = Type.getInstanceFields(Type.getClass(this)).iterator();
	while( $it13.hasNext() ) { var field = $it13.next();
	{
		f = Reflect.field(this,field);
		if(f instanceof hxbase.events.Event) {
			f.unbind(listener,handler);
		}
	}
	}}
}
hxbase.events.EventGroup.prototype.__class__ = hxbase.events.EventGroup;
hxbase.events.EventGroup.__interfaces__ = [haxe.Public,haxe.rtti.Infos];
hxbase.events._Event.Bubble = function(c,listener,handler) { if( c === $_ ) return; {
	this.a = true;
	this.l = listener;
	this.h = handler.method || handler;
	this._ = c;
	if(c.l == null) c.l = this;
	if(c.f != null) {
		this.n = c.f;
		this.n.p = this;
	}
	c.f = this;
}}
hxbase.events._Event.Bubble.__name__ = ["hxbase","events","_Event","Bubble"];
hxbase.events._Event.Bubble.prototype._ = null;
hxbase.events._Event.Bubble.prototype.a = null;
hxbase.events._Event.Bubble.prototype.boundTo = function(listener,handler) {
	if(this.l != listener) return false;
	if(handler == null) return true;
	return (this.l == handler.scope && this.h == handler.method);
}
hxbase.events._Event.Bubble.prototype.disable = function() {
	if(this.a == false) return;
	this.a = false;
	if(this.p == null) {
		this._.f = this.n;
		return;
	}
	var x = this.p;
	while(x != null && !x.a) x = x.p;
	if(x != null) x.n = this.n;
	else this._.f = this.n;
}
hxbase.events._Event.Bubble.prototype.enable = function() {
	if(this.a == true || this.l == null) return;
	this.a = true;
	var x;
	if(this.p == null) {
		this.n = this._.f;
		this._.f = this;
		return;
	}
	x = this.p;
	while(x != null && !x.a) x = x.p;
	if(x == null) {
		this.n = this._.f;
		this._.f = this;
	}
	else {
		this.n = x.n;
		x.n = this;
	}
}
hxbase.events._Event.Bubble.prototype.h = null;
hxbase.events._Event.Bubble.prototype.l = null;
hxbase.events._Event.Bubble.prototype.n = null;
hxbase.events._Event.Bubble.prototype.p = null;
hxbase.events._Event.Bubble.prototype.unbind = function(skipSelfDestruction) {
	if(this._ == null) return;
	this.disable();
	if(this == this._.l) this._.l = this.p;
	else if(this.p == null) {
		if(this.n != null && this.n.p == this) this.n.p = null;
		else {
			var x = this._.l;
			while(x != null && x.p != this) x = x.p;
			if(x != null) x.p = null;
		}
	}
	if(!skipSelfDestruction && this.l instanceof hxbase.events.EventHandlers) {
		var _h = this.l.handlers;
		{ var $it14 = Reflect.fields(_h).iterator();
		while( $it14.hasNext() ) { var f = $it14.next();
		if(Reflect.field(_h,f) == this) Reflect.setField(_h,f,null);
		}}
	}
	this._ = null;
	this.l = null;
	this.h = null;
	this.n = null;
}
hxbase.events._Event.Bubble.prototype.__class__ = hxbase.events._Event.Bubble;
hxbase.events._Event.Bubble.__interfaces__ = [hxbase.events.Binding];
Std = function() { }
Std.__name__ = ["Std"];
Std["is"] = function(v,t) {
	return js.Boot.__instanceof(v,t);
}
Std.string = function(s) {
	return js.Boot.__string_rec(s,"");
}
Std["int"] = function(x) {
	if(x < 0) return Math.ceil(x);
	return Math.floor(x);
}
Std.bool = function(x) {
	return (x !== 0 && x != null && x !== false);
}
Std.parseInt = function(x) {
	{
		var v = parseInt(x);
		if(Math.isNaN(v)) return null;
		return v;
	}
}
Std.parseFloat = function(x) {
	return parseFloat(x);
}
Std.chr = function(x) {
	return String.fromCharCode(x);
}
Std.ord = function(x) {
	if(x == "") return null;
	else return x.charCodeAt(0);
}
Std.random = function(x) {
	return Math.floor(Math.random() * x);
}
Std.resource = function(name) {
	return js.Boot.__res[name];
}
Std.prototype.__class__ = Std;
Lambda = function() { }
Lambda.__name__ = ["Lambda"];
Lambda.array = function(it) {
	var a = new Array();
	{ var $it15 = it.iterator();
	while( $it15.hasNext() ) { var i = $it15.next();
	a.push(i);
	}}
	return a;
}
Lambda.list = function(it) {
	var l = new List();
	{ var $it16 = it.iterator();
	while( $it16.hasNext() ) { var i = $it16.next();
	l.add(i);
	}}
	return l;
}
Lambda.map = function(it,f) {
	var l = new List();
	{ var $it17 = it.iterator();
	while( $it17.hasNext() ) { var x = $it17.next();
	l.add(f(x));
	}}
	return l;
}
Lambda.mapi = function(it,f) {
	var l = new List();
	var i = 0;
	{ var $it18 = it.iterator();
	while( $it18.hasNext() ) { var x = $it18.next();
	l.add(f(i++,x));
	}}
	return l;
}
Lambda.has = function(it,elt,cmp) {
	if(cmp == null) {
		{ var $it19 = it.iterator();
		while( $it19.hasNext() ) { var x = $it19.next();
		if(x == elt) return true;
		}}
	}
	else {
		{ var $it20 = it.iterator();
		while( $it20.hasNext() ) { var x = $it20.next();
		if(cmp(x,elt)) return true;
		}}
	}
	return false;
}
Lambda.exists = function(it,f) {
	{ var $it21 = it.iterator();
	while( $it21.hasNext() ) { var x = $it21.next();
	if(f(x)) return true;
	}}
	return false;
}
Lambda.foreach = function(it,f) {
	{ var $it22 = it.iterator();
	while( $it22.hasNext() ) { var x = $it22.next();
	if(!f(x)) return false;
	}}
	return true;
}
Lambda.iter = function(it,f) {
	{ var $it23 = it.iterator();
	while( $it23.hasNext() ) { var x = $it23.next();
	f(x);
	}}
}
Lambda.filter = function(it,f) {
	var l = new List();
	{ var $it24 = it.iterator();
	while( $it24.hasNext() ) { var x = $it24.next();
	if(f(x)) l.add(x);
	}}
	return l;
}
Lambda.fold = function(it,f,first) {
	{ var $it25 = it.iterator();
	while( $it25.hasNext() ) { var x = $it25.next();
	first = f(x,first);
	}}
	return first;
}
Lambda.count = function(it) {
	var n = 0;
	{ var $it26 = it.iterator();
	while( $it26.hasNext() ) { var _ = $it26.next();
	++n;
	}}
	return n;
}
Lambda.empty = function(it) {
	return !it.iterator().hasNext();
}
Lambda.prototype.__class__ = Lambda;
SpeedEvent = function(p) { if( p === $_ ) return; {
	hxbase.events.EventGroup.apply(this,[]);
}}
SpeedEvent.__name__ = ["SpeedEvent"];
SpeedEvent.__super__ = hxbase.events.EventGroup;
for(var k in hxbase.events.EventGroup.prototype ) SpeedEvent.prototype[k] = hxbase.events.EventGroup.prototype[k];
SpeedEvent.prototype.zoof = null;
SpeedEvent.prototype.__class__ = SpeedEvent;
haxe.rtti.XmlParser = function(p) { if( p === $_ ) return; {
	this.root = new Array();
}}
haxe.rtti.XmlParser.__name__ = ["haxe","rtti","XmlParser"];
haxe.rtti.XmlParser.prototype.curplatform = null;
haxe.rtti.XmlParser.prototype.defplat = function() {
	var l = new List();
	if(this.curplatform != null) l.add(this.curplatform);
	return l;
}
haxe.rtti.XmlParser.prototype.merge = function(t) {
	var inf = haxe.rtti.TypeApi.typeInfos(t);
	var pack = inf.path.split(".");
	var cur = this.root;
	var curpack = new Array();
	pack.pop();
	{ var $it27 = pack.iterator();
	while( $it27.hasNext() ) { var p = $it27.next();
	{
		var found = false;
		try {
			{ var $it28 = cur.iterator();
			while( $it28.hasNext() ) { var pk = $it28.next();
			var $e = (pk);
			switch( $e[0] ) {
			case "TPackage":
			var subs = $e[3], pname = $e[1];
			{
				if(pname == p) {
					found = true;
					cur = subs;
					throw "__break__";
				}
			}break;
			default:{
				null;
			}break;
			}
			}}
		} catch( e ) { if( e != "__break__" ) throw e; }
		curpack.push(p);
		if(!found) {
			var pk = new Array();
			cur.push(haxe.rtti.TypeTree.TPackage(p,curpack.join("."),pk));
			cur = pk;
		}
	}
	}}
	var prev = null;
	{ var $it29 = cur.iterator();
	while( $it29.hasNext() ) { var ct = $it29.next();
	{
		var tinf;
		try {
			tinf = haxe.rtti.TypeApi.typeInfos(ct);
		}
		catch( $e30 ) {
			{
				var e = $e30;
				continue;
			}
		}
		if(tinf.path == inf.path) {
			if(tinf.module == inf.module && tinf.doc == inf.doc && tinf.isPrivate == inf.isPrivate) var $e = (ct);
			switch( $e[0] ) {
			case "TClassdecl":
			var c = $e[1];
			{
				var $e = (t);
				switch( $e[0] ) {
				case "TClassdecl":
				var c2 = $e[1];
				{
					if(this.mergeClasses(c,c2)) return;
				}break;
				default:{
					null;
				}break;
				}
			}break;
			case "TEnumdecl":
			var e = $e[1];
			{
				var $e = (t);
				switch( $e[0] ) {
				case "TEnumdecl":
				var e2 = $e[1];
				{
					if(this.mergeEnums(e,e2)) return;
				}break;
				default:{
					null;
				}break;
				}
			}break;
			case "TTypedecl":
			var td = $e[1];
			{
				var $e = (t);
				switch( $e[0] ) {
				case "TTypedecl":
				var td2 = $e[1];
				{
					if(this.mergeTypedefs(td,td2)) return;
				}break;
				default:{
					null;
				}break;
				}
			}break;
			case "TPackage":
			{
				null;
			}break;
			}
			throw "Incompatibilities between " + tinf.path + " in " + tinf.platforms.join(",") + " and " + this.curplatform;
		}
	}
	}}
	cur.push(t);
}
haxe.rtti.XmlParser.prototype.mergeClasses = function(c,c2) {
	if(c.isInterface != c2.isInterface || c.isExtern != c2.isExtern) return false;
	if(this.curplatform != null) c.platforms.add(this.curplatform);
	{ var $it31 = c2.fields.iterator();
	while( $it31.hasNext() ) { var f2 = $it31.next();
	{
		var found = null;
		{ var $it32 = c.fields.iterator();
		while( $it32.hasNext() ) { var f = $it32.next();
		if(haxe.rtti.TypeApi.fieldEq(f,f2)) {
			found = f;
			break;
		}
		}}
		if(found == null) c.fields.add(f2);
		else if(this.curplatform != null) found.platforms.add(this.curplatform);
	}
	}}
	{ var $it33 = c2.statics.iterator();
	while( $it33.hasNext() ) { var f2 = $it33.next();
	{
		var found = null;
		{ var $it34 = c.statics.iterator();
		while( $it34.hasNext() ) { var f = $it34.next();
		if(haxe.rtti.TypeApi.fieldEq(f,f2)) {
			found = f;
			break;
		}
		}}
		if(found == null) c.statics.add(f2);
		else if(this.curplatform != null) found.platforms.add(this.curplatform);
	}
	}}
	return true;
}
haxe.rtti.XmlParser.prototype.mergeEnums = function(e,e2) {
	if(e.isExtern != e2.isExtern) return false;
	if(this.curplatform != null) e.platforms.add(this.curplatform);
	{ var $it35 = e2.constructors.iterator();
	while( $it35.hasNext() ) { var c2 = $it35.next();
	{
		var found = null;
		{ var $it36 = e.constructors.iterator();
		while( $it36.hasNext() ) { var c = $it36.next();
		if(haxe.rtti.TypeApi.constructorEq(c,c2)) {
			found = c;
			break;
		}
		}}
		if(found == null) return false;
		if(this.curplatform != null) found.platforms.add(this.curplatform);
	}
	}}
	return true;
}
haxe.rtti.XmlParser.prototype.mergeTypedefs = function(t,t2) {
	if(this.curplatform == null) return false;
	t.platforms.add(this.curplatform);
	t.types.set(this.curplatform,t2.type);
	return true;
}
haxe.rtti.XmlParser.prototype.mkPath = function(p) {
	return p;
}
haxe.rtti.XmlParser.prototype.mkRights = function(r) {
	return function($this) {
		var $r;
		switch(r) {
		case "null":{
			$r = haxe.rtti.Rights.RNo;
		}break;
		case "dynamic":{
			$r = haxe.rtti.Rights.RDynamic;
		}break;
		case "f9dynamic":{
			$r = haxe.rtti.Rights.RF9Dynamic;
		}break;
		default:{
			$r = haxe.rtti.Rights.RMethod(r);
		}break;
		}
		return $r;
	}(this);
}
haxe.rtti.XmlParser.prototype.mkTypeParams = function(p) {
	return p.split(":");
}
haxe.rtti.XmlParser.prototype.process = function(x,platform) {
	this.curplatform = platform;
	this.xroot(new haxe.xml.Fast(x));
}
haxe.rtti.XmlParser.prototype.processElement = function(x) {
	var c = new haxe.xml.Fast(x);
	return function($this) {
		var $r;
		switch(c.getName()) {
		case "class":{
			$r = haxe.rtti.TypeTree.TClassdecl($this.xclass(c));
		}break;
		case "enum":{
			$r = haxe.rtti.TypeTree.TEnumdecl($this.xenum(c));
		}break;
		case "typedef":{
			$r = haxe.rtti.TypeTree.TTypedecl($this.xtypedef(c));
		}break;
		default:{
			$r = $this.xerror(c);
		}break;
		}
		return $r;
	}(this);
}
haxe.rtti.XmlParser.prototype.root = null;
haxe.rtti.XmlParser.prototype.sort = function(l) {
	if(l == null) l = this.root;
	l.sort(function(e1,e2) {
		var n1 = function($this) {
			var $r;
			var $e = e1;
			switch( $e[0] ) {
			case "TPackage":
			var p = $e[1];
			{
				$r = " " + p;
			}break;
			default:{
				$r = haxe.rtti.TypeApi.typeInfos(e1).path;
			}break;
			}
			return $r;
		}(this);
		var n2 = function($this) {
			var $r;
			var $e = e2;
			switch( $e[0] ) {
			case "TPackage":
			var p = $e[1];
			{
				$r = " " + p;
			}break;
			default:{
				$r = haxe.rtti.TypeApi.typeInfos(e2).path;
			}break;
			}
			return $r;
		}(this);
		if(n1 > n2) return 1;
		return -1;
	});
	{ var $it37 = l.iterator();
	while( $it37.hasNext() ) { var x = $it37.next();
	var $e = (x);
	switch( $e[0] ) {
	case "TPackage":
	var l1 = $e[3];
	{
		this.sort(l1);
	}break;
	case "TClassdecl":
	var c = $e[1];
	{
		c.fields = this.sortFields(c.fields);
		c.statics = this.sortFields(c.statics);
	}break;
	case "TEnumdecl":
	var e = $e[1];
	{
		null;
	}break;
	case "TTypedecl":
	{
		null;
	}break;
	}
	}}
}
haxe.rtti.XmlParser.prototype.sortFields = function(fl) {
	var a = Lambda.array(fl);
	a.sort(function(f1,f2) {
		var v1 = haxe.rtti.TypeApi.isVar(f1.type);
		var v2 = haxe.rtti.TypeApi.isVar(f2.type);
		if(v1 && !v2) return -1;
		if(v2 && !v1) return 1;
		if(f1.name == "new") return -1;
		if(f2.name == "new") return 1;
		if(f1.name > f2.name) return 1;
		return -1;
	});
	return Lambda.list(a);
}
haxe.rtti.XmlParser.prototype.xclass = function(x) {
	var csuper = null;
	var doc = null;
	var dynamic = null;
	var interfaces = new List();
	var fields = new List();
	var statics = new List();
	{ var $it38 = x.getElements();
	while( $it38.hasNext() ) { var c = $it38.next();
	switch(c.getName()) {
	case "haxe_doc":{
		doc = c.getInnerData();
	}break;
	case "extends":{
		csuper = this.xpath(c);
	}break;
	case "implements":{
		interfaces.add(this.xpath(c));
	}break;
	case "haxe_dynamic":{
		dynamic = this.xtype(new haxe.xml.Fast(c.x.firstElement()));
	}break;
	default:{
		if(c.x.exists("static")) statics.add(this.xclassfield(c));
		else fields.add(this.xclassfield(c));
	}break;
	}
	}}
	return { platforms : this.defplat(), dynamic : dynamic, statics : statics, fields : fields, interfaces : interfaces, superClass : csuper, params : this.mkTypeParams(x.att.__resolve("params")), isInterface : x.x.exists("interface"), isExtern : x.x.exists("extern"), isPrivate : x.x.exists("private"), doc : doc, module : (x.has.__resolve("module")?this.mkPath(x.att.__resolve("module")):null), path : this.mkPath(x.att.__resolve("path"))}
}
haxe.rtti.XmlParser.prototype.xclassfield = function(x) {
	var e = x.getElements();
	var t = this.xtype(e.next());
	var doc = null;
	{ var $it39 = e;
	while( $it39.hasNext() ) { var c = $it39.next();
	switch(c.getName()) {
	case "haxe_doc":{
		doc = c.getInnerData();
	}break;
	default:{
		this.xerror(c);
	}break;
	}
	}}
	return { platforms : this.defplat(), params : (x.has.__resolve("params")?this.mkTypeParams(x.att.__resolve("params")):null), set : (x.has.__resolve("set")?this.mkRights(x.att.__resolve("set")):haxe.rtti.Rights.RNormal), get : (x.has.__resolve("get")?this.mkRights(x.att.__resolve("get")):haxe.rtti.Rights.RNormal), doc : doc, isPublic : x.x.exists("public"), type : t, name : x.getName()}
}
haxe.rtti.XmlParser.prototype.xenum = function(x) {
	var cl = new List();
	var doc = null;
	{ var $it40 = x.getElements();
	while( $it40.hasNext() ) { var c = $it40.next();
	if(c.getName() == "haxe_doc") doc = c.getInnerData();
	else cl.add(this.xenumfield(c));
	}}
	return { platforms : this.defplat(), constructors : cl, params : this.mkTypeParams(x.att.__resolve("params")), isExtern : x.x.exists("extern"), isPrivate : x.x.exists("private"), doc : doc, module : (x.has.__resolve("module")?this.mkPath(x.att.__resolve("module")):null), path : this.mkPath(x.att.__resolve("path"))}
}
haxe.rtti.XmlParser.prototype.xenumfield = function(x) {
	var args = null;
	var xdoc = x.x.elementsNamed("haxe_doc").next();
	if(x.has.__resolve("a")) {
		var names = x.att.__resolve("a").split(":");
		var elts = x.getElements();
		args = new List();
		{ var $it41 = names.iterator();
		while( $it41.hasNext() ) { var c = $it41.next();
		{
			var opt = false;
			if(c.charAt(0) == "?") {
				opt = true;
				c = c.substr(1);
			}
			args.add({ t : this.xtype(elts.next()), opt : opt, name : c});
		}
		}}
	}
	return { platforms : this.defplat(), doc : (xdoc == null?null:new haxe.xml.Fast(xdoc).getInnerData()), args : args, name : x.getName()}
}
haxe.rtti.XmlParser.prototype.xerror = function(c) {
	return function($this) {
		var $r;
		throw "Invalid " + c.getName();
		return $r;
	}(this);
}
haxe.rtti.XmlParser.prototype.xpath = function(x) {
	var path = this.mkPath(x.att.__resolve("path"));
	var params = new List();
	{ var $it42 = x.getElements();
	while( $it42.hasNext() ) { var c = $it42.next();
	params.add(this.xtype(c));
	}}
	return { params : params, path : path}
}
haxe.rtti.XmlParser.prototype.xroot = function(x) {
	{ var $it43 = x.x.elements();
	while( $it43.hasNext() ) { var c = $it43.next();
	this.merge(this.processElement(c));
	}}
}
haxe.rtti.XmlParser.prototype.xtype = function(x) {
	return function($this) {
		var $r;
		switch(x.getName()) {
		case "unknown":{
			$r = haxe.rtti.Type.TUnknown;
		}break;
		case "e":{
			$r = haxe.rtti.Type.TEnum($this.mkPath(x.att.__resolve("path")),$this.xtypeparams(x));
		}break;
		case "c":{
			$r = haxe.rtti.Type.TClass($this.mkPath(x.att.__resolve("path")),$this.xtypeparams(x));
		}break;
		case "t":{
			$r = haxe.rtti.Type.TTypedef($this.mkPath(x.att.__resolve("path")),$this.xtypeparams(x));
		}break;
		case "f":{
			$r = function($this) {
				var $r;
				var args = new List();
				var aname = x.att.__resolve("a").split(":");
				var eargs = aname.iterator();
				{ var $it44 = x.getElements();
				while( $it44.hasNext() ) { var e = $it44.next();
				{
					var opt = false;
					var a = eargs.next();
					if(a == null) a = "";
					if(a.charAt(0) == "?") {
						opt = true;
						a = a.substr(1);
					}
					args.add({ t : $this.xtype(e), opt : opt, name : a});
				}
				}}
				var ret = args.last();
				args.remove(ret);
				$r = haxe.rtti.Type.TFunction(args,ret.t);
				return $r;
			}($this);
		}break;
		case "a":{
			$r = function($this) {
				var $r;
				var fields = new List();
				{ var $it45 = x.getElements();
				while( $it45.hasNext() ) { var f = $it45.next();
				fields.add({ t : $this.xtype(new haxe.xml.Fast(f.x.firstElement())), name : f.getName()});
				}}
				$r = haxe.rtti.Type.TAnonymous(fields);
				return $r;
			}($this);
		}break;
		case "d":{
			$r = function($this) {
				var $r;
				var t = null;
				var tx = x.x.firstElement();
				if(tx != null) t = $this.xtype(new haxe.xml.Fast(tx));
				$r = haxe.rtti.Type.TDynamic(t);
				return $r;
			}($this);
		}break;
		default:{
			$r = $this.xerror(x);
		}break;
		}
		return $r;
	}(this);
}
haxe.rtti.XmlParser.prototype.xtypedef = function(x) {
	var doc = null;
	var t = null;
	{ var $it46 = x.getElements();
	while( $it46.hasNext() ) { var c = $it46.next();
	if(c.getName() == "haxe_doc") doc = c.getInnerData();
	else t = this.xtype(c);
	}}
	var types = new Hash();
	if(this.curplatform != null) types.set(this.curplatform,t);
	return { platforms : this.defplat(), types : types, type : t, params : this.mkTypeParams(x.att.__resolve("params")), isPrivate : x.x.exists("private"), doc : doc, module : (x.has.__resolve("module")?this.mkPath(x.att.__resolve("module")):null), path : this.mkPath(x.att.__resolve("path"))}
}
haxe.rtti.XmlParser.prototype.xtypeparams = function(x) {
	var p = new List();
	{ var $it47 = x.getElements();
	while( $it47.hasNext() ) { var c = $it47.next();
	p.add(this.xtype(c));
	}}
	return p;
}
haxe.rtti.XmlParser.prototype.__class__ = haxe.rtti.XmlParser;
hxbase.events.EventGroupArray = function(global) { if( global === $_ ) return; {
	if(!global) {
		var cl = Type.getClass(this);
		var id = cl.id;
		if(!(id >= 0)) id = cl.id = hxbase.events.EventGroupArray.getID(cl);
		if(hxbase.events._EventArray.GroupInstances.local[id] == null) hxbase.events._EventArray.GroupInstances.local[id] = new List();
		hxbase.events._EventArray.GroupInstances.local[id].add(this);
	}
	var $e = (hxbase.events.EventGroupArray.rttiParser.processElement(Xml.parse(Type.getClass(this).__rtti).firstElement()));
	switch( $e[0] ) {
	case "TClassdecl":
	var c = $e[1];
	{
		{ var $it48 = c.fields.iterator();
		while( $it48.hasNext() ) { var f = $it48.next();
		var $e = (f.type);
		switch( $e[0] ) {
		case "TClass":
		var params = $e[2], name = $e[1];
		{
			if(name == "hxbase.events.Event2") {
				Reflect.setField(this,f.name,new hxbase.events.Event2(this));
			}
		}break;
		default:{
			null;
		}break;
		}
		}}
	}break;
	default:{
		null;
	}break;
	}
}}
hxbase.events.EventGroupArray.__name__ = ["hxbase","events","EventGroupArray"];
hxbase.events.EventGroupArray._infos = null;
hxbase.events.EventGroupArray.getID = function(eg) {
	var i = hxbase.events._EventArray.GroupInstances.global.length;
	var g = Type.createInstance(eg,[true]);
	hxbase.events._EventArray.GroupInstances.global[i] = g;
	return i;
}
hxbase.events.EventGroupArray.prototype.unbind = function(listener,handler) {
	var f;
	{ var $it49 = Type.getInstanceFields(Type.getClass(this)).iterator();
	while( $it49.hasNext() ) { var field = $it49.next();
	{
		f = Reflect.field(this,field);
		if(f instanceof hxbase.events.Event2) f.unbind(listener,handler);
	}
	}}
}
hxbase.events.EventGroupArray.prototype.__class__ = hxbase.events.EventGroupArray;
hxbase.events.EventGroupArray.__interfaces__ = [haxe.rtti.Infos,haxe.Public];
SpeedEventArray = function(global) { if( global === $_ ) return; {
	hxbase.events.EventGroupArray.apply(this,[global]);
}}
SpeedEventArray.__name__ = ["SpeedEventArray"];
SpeedEventArray.__super__ = hxbase.events.EventGroupArray;
for(var k in hxbase.events.EventGroupArray.prototype ) SpeedEventArray.prototype[k] = hxbase.events.EventGroupArray.prototype[k];
SpeedEventArray.prototype.zoof = null;
SpeedEventArray.prototype.__class__ = SpeedEventArray;
VeryBasicSpeedtest = function(p) { if( p === $_ ) return; {
	this.countdown = 60;
	this.time = $closure(Date,"now");
	this.eventGroupTest();
	this.runTest1();
}}
VeryBasicSpeedtest.__name__ = ["VeryBasicSpeedtest"];
VeryBasicSpeedtest.main = function() {
	new VeryBasicSpeedtest();
}
VeryBasicSpeedtest.prototype.arrayTest = function() {
	this.start = this.time();
	{
		var _g1 = 0, _g = 10000;
		while(_g1 < _g) {
			var x = _g1;
			++_g1;
			this.event2.zoof.bind(this,$closure(this,"handler"));
		}
	}
	this.endBind = this.time();
	this.event2.zoof.call(10000,"Hello world!");
	this.end = this.time();
}
VeryBasicSpeedtest.prototype.bubbleTest = function() {
	this.start = this.time();
	{
		var _g1 = 0, _g = 10000;
		while(_g1 < _g) {
			var x = _g1;
			++_g1;
			this.event.zoof.bind(this,$closure(this,"handler"));
		}
	}
	this.endBind = this.time();
	this.event.zoof.call(10000,"Hello world!");
	this.end = this.time();
}
VeryBasicSpeedtest.prototype.count = null;
VeryBasicSpeedtest.prototype.countdown = null;
VeryBasicSpeedtest.prototype.end = null;
VeryBasicSpeedtest.prototype.endBind = null;
VeryBasicSpeedtest.prototype.event = null;
VeryBasicSpeedtest.prototype.event2 = null;
VeryBasicSpeedtest.prototype.eventGroupTest = function() {
	this.event = null;
	this.count = 0;
	this.start = this.time();
	{
		var _g1 = 0, _g = 100;
		while(_g1 < _g) {
			var x = _g1;
			++_g1;
			{
				this.event = new SpeedEvent();
				hxbase.events.EventGroup.rttiCache = [];
				this.count++;
			}
		}
	}
	this.event = new SpeedEvent();
	this.end = this.time();
	haxe.Log.trace("EventGroupTest( " + this.count + " ) -- Instantiate EventGroup (parse rtti xml): " + (this.end - this.start),{ methodName : "eventGroupTest", className : "VeryBasicSpeedtest", lineNumber : 54, fileName : "VeryBasicSpeedtest.hx"});
	this.event = null;
	this.count = 0;
	this.start = this.time();
	{
		var _g1 = 0, _g = 100;
		while(_g1 < _g) {
			var x = _g1;
			++_g1;
			{
				this.event = new SpeedEvent();
				this.count++;
			}
		}
	}
	this.end = this.time();
	haxe.Log.trace("EventGroupTest( " + this.count + " ) -- Instantiate EventGroup (with rtti cache): " + (this.end - this.start),{ methodName : "eventGroupTest", className : "VeryBasicSpeedtest", lineNumber : 64, fileName : "VeryBasicSpeedtest.hx"});
}
VeryBasicSpeedtest.prototype.handler = function(x,y) {
	this.count++;
}
VeryBasicSpeedtest.prototype.runTest1 = function() {
	{
		var _g1 = 0, _g = 8;
		while(_g1 < _g) {
			var x = _g1;
			++_g1;
			{
				this.count = 0;
				this.bubbleTest();
				haxe.Log.trace("BubbleTest( " + x + " ) -- Total: " + (this.end - this.start),{ methodName : "runTest1", className : "VeryBasicSpeedtest", lineNumber : 74, fileName : "VeryBasicSpeedtest.hx"});
				haxe.Log.trace("BubbleTest( " + x + " ) -- Binding: " + (this.endBind - this.start),{ methodName : "runTest1", className : "VeryBasicSpeedtest", lineNumber : 75, fileName : "VeryBasicSpeedtest.hx"});
				haxe.Log.trace("BubbleTest( " + x + " ) -- Dispatch: " + (this.end - this.endBind),{ methodName : "runTest1", className : "VeryBasicSpeedtest", lineNumber : 76, fileName : "VeryBasicSpeedtest.hx"});
				var s = this.time();
				this.event.zoof.unbind(this,$closure(this,"handler"));
				haxe.Log.trace("BubbleTest( " + x + " ) -- Unbind listers (" + this.count + "): " + (this.time() - s),{ methodName : "runTest1", className : "VeryBasicSpeedtest", lineNumber : 79, fileName : "VeryBasicSpeedtest.hx"});
			}
		}
	}
}
VeryBasicSpeedtest.prototype.runTest2 = function() {
	{
		var _g1 = 0, _g = 8;
		while(_g1 < _g) {
			var x = _g1;
			++_g1;
			{
				this.count = 0;
				this.arrayTest();
				haxe.Log.trace("ArrayTest( " + x + " ) -- Total: " + (this.end - this.start),{ methodName : "runTest2", className : "VeryBasicSpeedtest", lineNumber : 88, fileName : "VeryBasicSpeedtest.hx"});
				haxe.Log.trace("ArrayTest( " + x + " ) -- Binding: " + (this.endBind - this.start),{ methodName : "runTest2", className : "VeryBasicSpeedtest", lineNumber : 89, fileName : "VeryBasicSpeedtest.hx"});
				haxe.Log.trace("ArrayTest( " + x + " ) -- Dispatch: " + (this.end - this.endBind),{ methodName : "runTest2", className : "VeryBasicSpeedtest", lineNumber : 90, fileName : "VeryBasicSpeedtest.hx"});
				var s = this.time();
				this.event2.unbind(this);
				haxe.Log.trace("ArrayTest( " + x + " ) -- Unbind listers (" + this.count + "): " + (this.time() - s),{ methodName : "runTest2", className : "VeryBasicSpeedtest", lineNumber : 93, fileName : "VeryBasicSpeedtest.hx"});
			}
		}
	}
}
VeryBasicSpeedtest.prototype.start = null;
VeryBasicSpeedtest.prototype.time = null;
VeryBasicSpeedtest.prototype.__class__ = VeryBasicSpeedtest;
haxe.rtti.Type = { __ename__ : ["haxe","rtti","Type"] }
haxe.rtti.Type.TAnonymous = function(fields) { var $x = ["TAnonymous",fields]; $x.__enum__ = haxe.rtti.Type; return $x; }
haxe.rtti.Type.TClass = function(name,params) { var $x = ["TClass",name,params]; $x.__enum__ = haxe.rtti.Type; return $x; }
haxe.rtti.Type.TDynamic = function(t) { var $x = ["TDynamic",t]; $x.__enum__ = haxe.rtti.Type; return $x; }
haxe.rtti.Type.TEnum = function(name,params) { var $x = ["TEnum",name,params]; $x.__enum__ = haxe.rtti.Type; return $x; }
haxe.rtti.Type.TFunction = function(args,ret) { var $x = ["TFunction",args,ret]; $x.__enum__ = haxe.rtti.Type; return $x; }
haxe.rtti.Type.TTypedef = function(name,params) { var $x = ["TTypedef",name,params]; $x.__enum__ = haxe.rtti.Type; return $x; }
haxe.rtti.Type.TUnknown = ["TUnknown"];
haxe.rtti.Type.TUnknown.__enum__ = haxe.rtti.Type;
haxe.rtti.Rights = { __ename__ : ["haxe","rtti","Rights"] }
haxe.rtti.Rights.RDynamic = ["RDynamic"];
haxe.rtti.Rights.RDynamic.__enum__ = haxe.rtti.Rights;
haxe.rtti.Rights.RF9Dynamic = ["RF9Dynamic"];
haxe.rtti.Rights.RF9Dynamic.__enum__ = haxe.rtti.Rights;
haxe.rtti.Rights.RMethod = function(m) { var $x = ["RMethod",m]; $x.__enum__ = haxe.rtti.Rights; return $x; }
haxe.rtti.Rights.RNo = ["RNo"];
haxe.rtti.Rights.RNo.__enum__ = haxe.rtti.Rights;
haxe.rtti.Rights.RNormal = ["RNormal"];
haxe.rtti.Rights.RNormal.__enum__ = haxe.rtti.Rights;
haxe.rtti.TypeTree = { __ename__ : ["haxe","rtti","TypeTree"] }
haxe.rtti.TypeTree.TClassdecl = function(c) { var $x = ["TClassdecl",c]; $x.__enum__ = haxe.rtti.TypeTree; return $x; }
haxe.rtti.TypeTree.TEnumdecl = function(e) { var $x = ["TEnumdecl",e]; $x.__enum__ = haxe.rtti.TypeTree; return $x; }
haxe.rtti.TypeTree.TPackage = function(name,full,subs) { var $x = ["TPackage",name,full,subs]; $x.__enum__ = haxe.rtti.TypeTree; return $x; }
haxe.rtti.TypeTree.TTypedecl = function(t) { var $x = ["TTypedecl",t]; $x.__enum__ = haxe.rtti.TypeTree; return $x; }
haxe.rtti.TypeApi = function() { }
haxe.rtti.TypeApi.__name__ = ["haxe","rtti","TypeApi"];
haxe.rtti.TypeApi.typeInfos = function(t) {
	var inf;
	var $e = (t);
	switch( $e[0] ) {
	case "TClassdecl":
	var c = $e[1];
	{
		inf = c;
	}break;
	case "TEnumdecl":
	var e = $e[1];
	{
		inf = e;
	}break;
	case "TTypedecl":
	var t1 = $e[1];
	{
		inf = t1;
	}break;
	case "TPackage":
	{
		throw "Unexpected Package";
	}break;
	}
	return inf;
}
haxe.rtti.TypeApi.isVar = function(t) {
	return function($this) {
		var $r;
		var $e = (t);
		switch( $e[0] ) {
		case "TFunction":
		{
			$r = false;
		}break;
		default:{
			$r = true;
		}break;
		}
		return $r;
	}(this);
}
haxe.rtti.TypeApi.leq = function(f,l1,l2) {
	var it = l2.iterator();
	{ var $it50 = l1.iterator();
	while( $it50.hasNext() ) { var e1 = $it50.next();
	{
		if(!it.hasNext()) return false;
		var e2 = it.next();
		if(!f(e1,e2)) return false;
	}
	}}
	if(it.hasNext()) return false;
	return true;
}
haxe.rtti.TypeApi.rightsEq = function(r1,r2) {
	if(r1 == r2) return true;
	var $e = (r1);
	switch( $e[0] ) {
	case "RMethod":
	var m1 = $e[1];
	{
		var $e = (r2);
		switch( $e[0] ) {
		case "RMethod":
		var m2 = $e[1];
		{
			return m1 == m2;
		}break;
		default:{
			null;
		}break;
		}
	}break;
	default:{
		null;
	}break;
	}
	return false;
}
haxe.rtti.TypeApi.typeEq = function(t1,t2) {
	var $e = (t1);
	switch( $e[0] ) {
	case "TUnknown":
	{
		return t2 == haxe.rtti.Type.TUnknown;
	}break;
	case "TEnum":
	var params = $e[2], name = $e[1];
	{
		var $e = (t2);
		switch( $e[0] ) {
		case "TEnum":
		var params2 = $e[2], name2 = $e[1];
		{
			return name == name2 && haxe.rtti.TypeApi.leq($closure(haxe.rtti.TypeApi,"typeEq"),params,params2);
		}break;
		default:{
			null;
		}break;
		}
	}break;
	case "TClass":
	var params = $e[2], name = $e[1];
	{
		var $e = (t2);
		switch( $e[0] ) {
		case "TClass":
		var params2 = $e[2], name2 = $e[1];
		{
			return name == name2 && haxe.rtti.TypeApi.leq($closure(haxe.rtti.TypeApi,"typeEq"),params,params2);
		}break;
		default:{
			null;
		}break;
		}
	}break;
	case "TTypedef":
	var params = $e[2], name = $e[1];
	{
		var $e = (t2);
		switch( $e[0] ) {
		case "TTypedef":
		var params2 = $e[2], name2 = $e[1];
		{
			return name == name2 && haxe.rtti.TypeApi.leq($closure(haxe.rtti.TypeApi,"typeEq"),params,params2);
		}break;
		default:{
			null;
		}break;
		}
	}break;
	case "TFunction":
	var ret = $e[2], args = $e[1];
	{
		var $e = (t2);
		switch( $e[0] ) {
		case "TFunction":
		var ret2 = $e[2], args2 = $e[1];
		{
			return haxe.rtti.TypeApi.leq(function(a,b) {
				return a.name == b.name && a.opt == b.opt && haxe.rtti.TypeApi.typeEq(a.t,b.t);
			},args,args2) && haxe.rtti.TypeApi.typeEq(ret,ret2);
		}break;
		default:{
			null;
		}break;
		}
	}break;
	case "TAnonymous":
	var fields = $e[1];
	{
		var $e = (t2);
		switch( $e[0] ) {
		case "TAnonymous":
		var fields2 = $e[1];
		{
			return haxe.rtti.TypeApi.leq(function(a,b) {
				return a.name == b.name && haxe.rtti.TypeApi.typeEq(a.t,b.t);
			},fields,fields2);
		}break;
		default:{
			null;
		}break;
		}
	}break;
	case "TDynamic":
	var t = $e[1];
	{
		var $e = (t2);
		switch( $e[0] ) {
		case "TDynamic":
		var t21 = $e[1];
		{
			if((t == null) != (t21 == null)) return false;
			return t == null || haxe.rtti.TypeApi.typeEq(t,t21);
		}break;
		default:{
			null;
		}break;
		}
	}break;
	}
	return false;
}
haxe.rtti.TypeApi.fieldEq = function(f1,f2) {
	if(f1.name != f2.name) return false;
	if(!haxe.rtti.TypeApi.typeEq(f1.type,f2.type)) return false;
	if(f1.isPublic != f2.isPublic) return false;
	if(f1.doc != f2.doc) return false;
	if(!haxe.rtti.TypeApi.rightsEq(f1.get,f2.get)) return false;
	if(!haxe.rtti.TypeApi.rightsEq(f1.set,f2.set)) return false;
	if((f1.params == null) != (f2.params == null)) return false;
	if(f1.params != null && f1.params.join(":") != f2.params.join(":")) return false;
	return true;
}
haxe.rtti.TypeApi.constructorEq = function(c1,c2) {
	if(c1.name != c2.name) return false;
	if(c1.doc != c2.doc) return false;
	if((c1.args == null) != (c2.args == null)) return false;
	if(c1.args != null && !haxe.rtti.TypeApi.leq(function(a,b) {
		return a.name == b.name && a.opt == b.opt && haxe.rtti.TypeApi.typeEq(a.t,b.t);
	},c1.args,c2.args)) return false;
	return true;
}
haxe.rtti.TypeApi.prototype.__class__ = haxe.rtti.TypeApi;
Hash = function(p) { if( p === $_ ) return; {
	{
		this.h = {}
		if(this.h.__proto__ != null) {
			this.h.__proto__ = null;
			delete(this.h.__proto__);
		}
		else null;
	}
}}
Hash.__name__ = ["Hash"];
Hash.prototype.exists = function(key) {
	try {
		return this.hasOwnProperty.call(this.h,key);
	}
	catch( $e51 ) {
		{
			var e = $e51;
			{
				
				for(var i in this.h)
					if( i == key ) return true;
			;
				return false;
			}
		}
	}
}
Hash.prototype.get = function(key) {
	return this.h[key];
}
Hash.prototype.h = null;
Hash.prototype.iterator = function() {
	return { next : function() {
		var i = this.it.next();
		return this.ref[i];
	}, hasNext : function() {
		return this.it.hasNext();
	}, it : this.keys(), ref : this.h}
}
Hash.prototype.keys = function() {
	var a = new Array();
	
			for(var i in this.h)
				a.push(i);
		;
	return a.iterator();
}
Hash.prototype.remove = function(key) {
	if(!this.exists(key)) return false;
	delete(this.h[key]);
	return true;
}
Hash.prototype.set = function(key,value) {
	this.h[key] = value;
}
Hash.prototype.toString = function() {
	var s = new StringBuf();
	s.add("{");
	var it = this.keys();
	{ var $it52 = it;
	while( $it52.hasNext() ) { var i = $it52.next();
	{
		s.add(i);
		s.add(" => ");
		s.add(Std.string(this.get(i)));
		if(it.hasNext()) s.add(", ");
	}
	}}
	s.add("}");
	return s.toString();
}
Hash.prototype.__class__ = Hash;
List = function(p) { if( p === $_ ) return; {
	this.length = 0;
}}
List.__name__ = ["List"];
List.prototype.add = function(item) {
	var x = [item,null];
	if(this.h == null) this.h = x;
	else this.q[1] = x;
	this.q = x;
	this.length++;
}
List.prototype.clear = function() {
	this.h = null;
	this.length = 0;
}
List.prototype.filter = function(f) {
	var l2 = new List();
	var l = this.h;
	while(l != null) {
		var v = l[0];
		l = l[1];
		if(f(v)) l2.add(v);
	}
	return l2;
}
List.prototype.first = function() {
	return (this.h == null?null:this.h[0]);
}
List.prototype.h = null;
List.prototype.isEmpty = function() {
	return (this.h == null);
}
List.prototype.iterator = function() {
	return { next : function() {
		{
			if(this.h == null) return null;
			var x = this.h[0];
			this.h = this.h[1];
			return x;
		}
	}, hasNext : function() {
		return (this.h != null);
	}, h : this.h}
}
List.prototype.join = function(sep) {
	var s = new StringBuf();
	var first = true;
	var l = this.h;
	while(l != null) {
		if(first) first = false;
		else s.add(sep);
		s.add(l[0]);
		l = l[1];
	}
	return s.toString();
}
List.prototype.last = function() {
	return (this.q == null?null:this.q[0]);
}
List.prototype.length = null;
List.prototype.map = function(f) {
	var b = new List();
	var l = this.h;
	while(l != null) {
		var v = l[0];
		l = l[1];
		b.add(f(v));
	}
	return b;
}
List.prototype.pop = function() {
	if(this.h == null) return null;
	var x = this.h[0];
	this.h = this.h[1];
	if(this.h == null) this.q = null;
	this.length--;
	return x;
}
List.prototype.push = function(item) {
	var x = [item,this.h];
	this.h = x;
	if(this.q == null) this.q = x;
	this.length++;
}
List.prototype.q = null;
List.prototype.remove = function(v) {
	var prev = null;
	var l = this.h;
	while(l != null) {
		if(l[0] == v) {
			if(prev == null) this.h = l[1];
			else prev[1] = l[1];
			if(this.q == l) this.q = prev;
			this.length--;
			return true;
		}
		prev = l;
		l = l[1];
	}
	return false;
}
List.prototype.toString = function() {
	var s = new StringBuf();
	var first = true;
	var l = this.h;
	s.add("{");
	while(l != null) {
		if(first) first = false;
		else s.add(", ");
		s.add(l[0]);
		l = l[1];
	}
	s.add("}");
	return s.toString();
}
List.prototype.__class__ = List;
Reflect = function() { }
Reflect.__name__ = ["Reflect"];
Reflect.empty = function() {
	return {}
}
Reflect.hasField = function(o,field) {
	{
		if(o.hasOwnProperty != null) return o.hasOwnProperty(field);
		var arr = Reflect.fields(o);
		{ var $it53 = arr.iterator();
		while( $it53.hasNext() ) { var t = $it53.next();
		if(t == field) return true;
		}}
		return false;
	}
}
Reflect.field = function(o,field) {
	try {
		return o[field];
	}
	catch( $e54 ) {
		{
			var e = $e54;
			{
				return null;
			}
		}
	}
}
Reflect.setField = function(o,field,value) {
	o[field] = value;
}
Reflect.callMethod = function(o,func,args) {
	return func.apply(o,args);
}
Reflect.fields = function(o) {
	if(o == null) return new Array();
	{
		var a = new Array();
		if(o.hasOwnProperty) {
			
					for(var i in o)
						if( o.hasOwnProperty(i) )
							a.push(i);
				;
		}
		else {
			var t;
			try {
				t = o.__proto__;
			}
			catch( $e55 ) {
				{
					var e = $e55;
					{
						t = null;
					}
				}
			}
			if(t != null) o.__proto__ = null;
			
					for(var i in o)
						if( i != "__proto__" )
							a.push(i);
				;
			if(t != null) o.__proto__ = t;
		}
		return a;
	}
}
Reflect.isFunction = function(f) {
	return typeof(f) == "function" && f.__name__ == null;
}
Reflect.compareMethods = function(f1,f2) {
	if(f1 == f2) return true;
	if(!Reflect.isFunction(f1) || !Reflect.isFunction(f2)) return false;
	return f1.scope == f2.scope && f1.method == f2.method && f1.method != null;
}
Reflect.isObject = function(v) {
	if(v == null) return false;
	var t = typeof(v);
	return (t == "string" || (t == "object" && !v.__enum__) || (t == "function" && v.__name__ != null));
}
Reflect.deleteField = function(o,f) {
	{
		if(!Reflect.hasField(o,f)) return false;
		delete(o[f]);
		return true;
	}
}
Reflect.copy = function(o) {
	var o2 = Reflect.empty();
	{ var $it56 = Reflect.fields(o).iterator();
	while( $it56.hasNext() ) { var f = $it56.next();
	Reflect.setField(o2,f,Reflect.field(o,f));
	}}
	return o2;
}
Reflect.makeVarArgs = function(f) {
	return function() {
		var a = new Array();
		{
			var _g1 = 0, _g = arguments.length;
			while(_g1 < _g) {
				var i = _g1;
				++_g1;
				a.push(arguments[i]);
			}
		}
		return f(a);
	}
}
Reflect.prototype.__class__ = Reflect;
StringBuf = function(p) { if( p === $_ ) return; {
	this.b = "";
}}
StringBuf.__name__ = ["StringBuf"];
StringBuf.prototype.add = function(x) {
	this.b += x;
}
StringBuf.prototype.addChar = function(c) {
	this.b += String.fromCharCode(c);
}
StringBuf.prototype.addSub = function(s,pos,len) {
	this.b += s.substr(pos,len);
}
StringBuf.prototype.b = null;
StringBuf.prototype.toString = function() {
	return this.b;
}
StringBuf.prototype.__class__ = StringBuf;
hxbase.events._EventArray = {}
hxbase.events._EventArray.GroupInstances = function() { }
hxbase.events._EventArray.GroupInstances.__name__ = ["hxbase","events","_EventArray","GroupInstances"];
hxbase.events._EventArray.GroupInstances.global = null;
hxbase.events._EventArray.GroupInstances.local = null;
hxbase.events._EventArray.GroupInstances.prototype.__class__ = hxbase.events._EventArray.GroupInstances;
hxbase.events.Event2 = function(group) { if( group === $_ ) return; {
	this.parent = group;
	this.call = $closure(this,"dispatchCall");
	this.bubbleChain = new Array();
}}
hxbase.events.Event2.__name__ = ["hxbase","events","Event2"];
hxbase.events.Event2.current = null;
hxbase.events.Event2.global = function(eventGroup) {
	var id = Type.getClass(eventGroup).id;
	if(!(id >= 0)) throw "No ID found";
	var g = hxbase.events._EventArray.GroupInstances.global[id];
	if(g == null) throw "Null EventGroup. Are you sure you specified an EventGroup class as parameter?";
	return g;
}
hxbase.events.Event2.bind = function(group,handlers) {
	null;
}
hxbase.events.Event2.unbind = function(listener,handler,skipLocalDispatchers,skipGlobalDispatchers) {
	if(!skipLocalDispatchers) {
		var l = hxbase.events._EventArray.GroupInstances.local;
		{
			var _g1 = 0, _g = l.length;
			while(_g1 < _g) {
				var id = _g1;
				++_g1;
				{ var $it57 = l[id].iterator();
				while( $it57.hasNext() ) { var group = $it57.next();
				{
					group.unbind(listener,handler);
				}
				}}
			}
		}
	}
	if(!skipGlobalDispatchers) {
		var l = hxbase.events._EventArray.GroupInstances.global;
		{
			var _g1 = 0, _g = l.length;
			while(_g1 < _g) {
				var id = _g1;
				++_g1;
				{
					l[id].unbind(listener,handler);
				}
			}
		}
	}
}
hxbase.events.Event2.prototype.bind = function(listener,handler) {
	this.bubbleChain.push({ h : handler.method, l : listener});
}
hxbase.events.Event2.prototype.bubbleChain = null;
hxbase.events.Event2.prototype.call = null;
hxbase.events.Event2.prototype.dispatchCall = function() {
	hxbase.events.Event2.current = this;
	this.doStopPropagation = false;
	var bc = this.bubbleChain;
	var z = bc.length;
	{
		var _g1 = 0, _g = z;
		while(_g1 < _g) {
			var i = _g1;
			++_g1;
			{
				if(bc[i] == null) continue;
				if(bc[i].h.apply(bc[i].l,arguments) === true) break;
				if(this.doStopPropagation) break;
				else null;
			}
		}
	}
	hxbase.events.Event2.current = null;
	this.doStopPropagation = false;
}
hxbase.events.Event2.prototype.doStopPropagation = null;
hxbase.events.Event2.prototype.methodEquals = function(o1,m1,m2) {
	if(m1 != m2) {
		if(m1.o) return (o1 === m2.o && m1 === m2.f);
		return false;
	}
	return true;
}
hxbase.events.Event2.prototype.parent = null;
hxbase.events.Event2.prototype.stopPropagation = function() {
	if(hxbase.events.Event2.current == this) this.doStopPropagation = true;
}
hxbase.events.Event2.prototype.unbind = function(listener,handler) {
	var bc = this.bubbleChain;
	if(handler == null) {
		var _g1 = 0, _g = bc.length;
		while(_g1 < _g) {
			var i = _g1;
			++_g1;
			{
				if(bc[i] == null) continue;
				if(bc[i].l == listener) bc[i] = null;
			}
		}
	}
	else {
		var _g1 = 0, _g = bc.length;
		while(_g1 < _g) {
			var i = _g1;
			++_g1;
			{
				if(bc[i] == null) continue;
				if(bc[i].l == listener && this.methodEquals(bc[i].l,bc[i].h,handler)) bc.splice(i,1);
			}
		}
	}
}
hxbase.events.Event2.prototype.__class__ = hxbase.events.Event2;
IntIter = function(min,max) { if( min === $_ ) return; {
	this.min = min;
	this.max = max;
}}
IntIter.__name__ = ["IntIter"];
IntIter.prototype.hasNext = function() {
	return this.min < this.max;
}
IntIter.prototype.max = null;
IntIter.prototype.min = null;
IntIter.prototype.next = function() {
	return this.min++;
}
IntIter.prototype.__class__ = IntIter;
$Main = function() { }
$Main.__name__ = ["@Main"];
$Main.prototype.__class__ = $Main;
$_ = {}
js.Boot.__res = {}
js.Boot.__init();
{
	Xml = js.JsXml__;
	Xml.__name__ = ["Xml"];
	Xml.Element = "element";
	Xml.PCData = "pcdata";
	Xml.CData = "cdata";
	Xml.Comment = "comment";
	Xml.DocType = "doctype";
	Xml.Prolog = "prolog";
	Xml.Document = "document";
}
{
	
			onerror = function(msg,url,line) {
				var f = js.Lib.onerror;
				if( f == null )
					return false;
				return f(msg,[url+":"+line]);
			}
		;
}
{
	Date.now = function() {
		return new Date();
	}
	Date.fromTime = function(t) {
		var d = new Date();
		d["setTime"](t);
		return d;
	}
	Date.fromString = function(s) {
		switch(s.length) {
		case 8:{
			var k = s.split(":");
			var d = new Date();
			d["setTime"](0);
			d["setUTCHours"](k[0]);
			d["setUTCMinutes"](k[1]);
			d["setUTCSeconds"](k[2]);
			return d;
		}break;
		case 10:{
			var k = s.split("-");
			return new Date(k[0],k[1] - 1,k[2],0,0,0);
		}break;
		case 19:{
			var k = s.split(" ");
			var y = k[0].split("-");
			var t = k[1].split(":");
			return new Date(y[0],y[1] - 1,y[2],t[0],t[1],t[2]);
		}break;
		default:{
			throw "Invalid date format : " + s;
		}break;
		}
	}
	Date.prototype["toString"] = function() {
		var m = this.getMonth() + 1;
		var d = this.getDate();
		var h = this.getHours();
		var mi = this.getMinutes();
		var s = this.getSeconds();
		return this.getFullYear() + "-" + ((m < 10?"0" + m:"" + m)) + "-" + ((d < 10?"0" + d:"" + d)) + " " + ((h < 10?"0" + h:"" + h)) + ":" + ((mi < 10?"0" + mi:"" + mi)) + ":" + ((s < 10?"0" + s:"" + s));
	}
	Date.prototype.__class__ = Date;
	Date.__name__ = ["Date"];
}
{
	Math.NaN = Number["NaN"];
	Math.NEGATIVE_INFINITY = Number["NEGATIVE_INFINITY"];
	Math.POSITIVE_INFINITY = Number["POSITIVE_INFINITY"];
	Math.isFinite = function(i) {
		return isFinite(i);
	}
	Math.isNaN = function(i) {
		return isNaN(i);
	}
}
{
	hxbase.events._EventArray.GroupInstances.global = new Array();
	hxbase.events._EventArray.GroupInstances.local = new Array();
}
js.JsXml__.enode = new EReg("^<([a-zA-Z0-9:_-]+)","");
js.JsXml__.ecdata = new EReg("^<!\\[CDATA\\[","i");
js.JsXml__.edoctype = new EReg("^<!DOCTYPE","i");
js.JsXml__.eend = new EReg("^</([a-zA-Z0-9:_-]+)>","");
js.JsXml__.epcdata = new EReg("^[^<]+","");
js.JsXml__.ecomment = new EReg("^<!--","");
js.JsXml__.eprolog = new EReg("^<\\?[^\\?]+\\?>","");
js.JsXml__.eattribute = new EReg("^\\s*([a-zA-Z0-9:_-]+)\\s*=\\s*([\"'])([^\\2]*?)\\2","");
js.JsXml__.eclose = new EReg("^[ \\r\\n\\t]*(>|(/>))","");
js.JsXml__.ecdata_end = new EReg("\\]\\]>","");
js.JsXml__.edoctype_elt = new EReg("[\\[|\\]>]","");
js.JsXml__.ecomment_end = new EReg("-->","");
js.Lib.document = document;
js.Lib.window = window;
js.Lib.onerror = null;
hxbase.events.EventGroup.__rtti = "<class path=\"hxbase.events.EventGroup\" params=\"\" file=\"hxbase/events/Event.hx\" module=\"hxbase.events.Event\">\n\t<implements path=\"haxe.Public\"/>\n\t<implements path=\"haxe.rtti.Infos\"/>\n\t<global public=\"1\" line=\"272\" static=\"1\"><c path=\"Array\"><c path=\"hxbase.events.EventGroup\"/></c></global>\n\t<rttiCache line=\"275\" static=\"1\"><c path=\"Array\"><c path=\"Array\"><c path=\"String\"/></c></c></rttiCache>\n\t<getClass line=\"286\"><f a=\"\"><c path=\"Class\"><c path=\"hxbase.events.EventGroup\"/></c></f></getClass>\n\t<init line=\"300\"><f a=\"\"><e path=\"Void\"/></f></init>\n\t<bind public=\"1\" line=\"327\"><f a=\"cl\">\n\t<d/>\n\t<e path=\"Void\"/>\n</f></bind>\n\t<unbind public=\"1\" line=\"332\"><f a=\"listener:?handler\">\n\t<d/>\n\t<d/>\n\t<e path=\"Void\"/>\n</f></unbind>\n\t<new public=\"1\" line=\"277\"><f a=\"\"><e path=\"Void\"/></f></new>\n</class>";
hxbase.events.EventGroup.global = new Array();
hxbase.events.EventGroup.rttiCache = new Array();
SpeedEvent.__rtti = "<class path=\"SpeedEvent\" params=\"\" file=\"VeryBasicSpeedtest.hx\" module=\"VeryBasicSpeedtest\">\n\t<extends path=\"hxbase.events.EventGroup\"/>\n\t<zoof public=\"1\"><c path=\"hxbase.events.Event\"><f a=\":\">\n\t<c path=\"Int\"/>\n\t<c path=\"String\"/>\n\t<e path=\"Void\"/>\n</f></c></zoof>\n\t<new public=\"1\" line=\"4\"><f a=\"\"><e path=\"Void\"/></f></new>\n</class>";
hxbase.events.EventGroupArray.__rtti = "<class path=\"hxbase.events.EventGroupArray\" params=\"\" file=\"hxbase/events/EventArray.hx\" module=\"hxbase.events.EventArray\">\n\t<implements path=\"haxe.rtti.Infos\"/>\n\t<implements path=\"haxe.Public\"/>\n\t<_infos static=\"1\"><e path=\"haxe.rtti.TypeTree\"/></_infos>\n\t<rttiParser line=\"71\" static=\"1\"><c path=\"haxe.rtti.XmlParser\"/></rttiParser>\n\t<getID public=\"1\" params=\"EventGroupClass\" line=\"74\" static=\"1\"><f a=\"eg\">\n\t<t path=\"hxbase.events._EventArray.ClassT\"><e path=\"getID.EventGroupClass\"/></t>\n\t<c path=\"Int\"/>\n</f></getID>\n\t<unbind public=\"1\" line=\"122\"><f a=\"listener:?handler\">\n\t<c path=\"VeryBasicSpeedtest\"/>\n\t<unknown/>\n\t<e path=\"Void\"/>\n</f></unbind>\n\t<new public=\"1\" line=\"89\"><f a=\"?global\">\n\t<e path=\"Bool\"/>\n\t<e path=\"Void\"/>\n</f></new>\n</class>";
hxbase.events.EventGroupArray.rttiParser = new haxe.rtti.XmlParser();
SpeedEventArray.__rtti = "<class path=\"SpeedEventArray\" params=\"\" file=\"VeryBasicSpeedtest.hx\" module=\"VeryBasicSpeedtest\">\n\t<extends path=\"hxbase.events.EventGroupArray\"/>\n\t<zoof public=\"1\"><c path=\"hxbase.events.Event2\"><f a=\":\">\n\t<c path=\"Int\"/>\n\t<c path=\"String\"/>\n\t<e path=\"Void\"/>\n</f></c></zoof>\n\t<new public=\"1\" line=\"9\"><f a=\"?global\">\n\t<e path=\"Bool\"/>\n\t<e path=\"Void\"/>\n</f></new>\n</class>";
$Main.init = VeryBasicSpeedtest.main();
